home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_userdict.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  8KB  |  303 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. import unittest
  5. from test import test_support, mapping_tests
  6. import UserDict
  7. d0 = { }
  8. d1 = {
  9.     'one': 1 }
  10. d2 = {
  11.     'one': 1,
  12.     'two': 2 }
  13. d3 = {
  14.     'one': 1,
  15.     'two': 3,
  16.     'three': 5 }
  17. d4 = {
  18.     'one': None,
  19.     'two': None }
  20. d5 = {
  21.     'one': 1,
  22.     'two': 1 }
  23.  
  24. class UserDictTest(mapping_tests.TestHashMappingProtocol):
  25.     type2test = UserDict.IterableUserDict
  26.     
  27.     def test_all(self):
  28.         u = UserDict.UserDict()
  29.         u0 = UserDict.UserDict(d0)
  30.         u1 = UserDict.UserDict(d1)
  31.         u2 = UserDict.IterableUserDict(d2)
  32.         uu = UserDict.UserDict(u)
  33.         uu0 = UserDict.UserDict(u0)
  34.         uu1 = UserDict.UserDict(u1)
  35.         uu2 = UserDict.UserDict(u2)
  36.         self.assertEqual(UserDict.UserDict(one = 1, two = 2), d2)
  37.         self.assertEqual(UserDict.UserDict([
  38.             ('one', 1),
  39.             ('two', 2)]), d2)
  40.         self.assertEqual(UserDict.UserDict(dict = [
  41.             ('one', 1),
  42.             ('two', 2)]), d2)
  43.         self.assertEqual(UserDict.UserDict([
  44.             ('one', 1),
  45.             ('two', 2)], two = 3, three = 5), d3)
  46.         self.assertEqual(UserDict.UserDict.fromkeys('one two'.split()), d4)
  47.         self.assertEqual(UserDict.UserDict().fromkeys('one two'.split()), d4)
  48.         self.assertEqual(UserDict.UserDict.fromkeys('one two'.split(), 1), d5)
  49.         self.assertEqual(UserDict.UserDict().fromkeys('one two'.split(), 1), d5)
  50.         self.assert_(u1.fromkeys('one two'.split()) is not u1)
  51.         self.assert_(isinstance(u1.fromkeys('one two'.split()), UserDict.UserDict))
  52.         self.assert_(isinstance(u2.fromkeys('one two'.split()), UserDict.IterableUserDict))
  53.         self.assertEqual(str(u0), str(d0))
  54.         self.assertEqual(repr(u1), repr(d1))
  55.         self.assertEqual(`u2`, `d2`)
  56.         all = [
  57.             d0,
  58.             d1,
  59.             d2,
  60.             u,
  61.             u0,
  62.             u1,
  63.             u2,
  64.             uu,
  65.             uu0,
  66.             uu1,
  67.             uu2]
  68.         for a in all:
  69.             for b in all:
  70.                 self.assertEqual(cmp(a, b), cmp(len(a), len(b)))
  71.             
  72.         
  73.         self.assertEqual(u2['one'], 1)
  74.         self.assertRaises(KeyError, u1.__getitem__, 'two')
  75.         u3 = UserDict.UserDict(u2)
  76.         u3['two'] = 2
  77.         u3['three'] = 3
  78.         del u3['three']
  79.         self.assertRaises(KeyError, u3.__delitem__, 'three')
  80.         u3.clear()
  81.         self.assertEqual(u3, { })
  82.         u2a = u2.copy()
  83.         self.assertEqual(u2a, u2)
  84.         u2b = UserDict.UserDict(x = 42, y = 23)
  85.         u2c = u2b.copy()
  86.         self.assertEqual(u2b, u2c)
  87.         
  88.         class MyUserDict(UserDict.UserDict):
  89.             
  90.             def display(self):
  91.                 print self
  92.  
  93.  
  94.         m2 = MyUserDict(u2)
  95.         m2a = m2.copy()
  96.         self.assertEqual(m2a, m2)
  97.         m2['foo'] = 'bar'
  98.         self.assertNotEqual(m2a, m2)
  99.         self.assertEqual(u2.keys(), d2.keys())
  100.         self.assertEqual(u2.items(), d2.items())
  101.         self.assertEqual(u2.values(), d2.values())
  102.         for i in u2.keys():
  103.             self.assert_(u2.has_key(i))
  104.             self.assert_(i in u2)
  105.             self.assertEqual(u1.has_key(i), d1.has_key(i))
  106.             self.assertEqual(i in u1, i in d1)
  107.             self.assertEqual(u0.has_key(i), d0.has_key(i))
  108.             self.assertEqual(i in u0, i in d0)
  109.         
  110.         t = UserDict.UserDict()
  111.         t.update(u2)
  112.         self.assertEqual(t, u2)
  113.         
  114.         class Items:
  115.             
  116.             def items(self):
  117.                 return (('x', 42), ('y', 23))
  118.  
  119.  
  120.         t = UserDict.UserDict()
  121.         t.update(Items())
  122.         self.assertEqual(t, {
  123.             'x': 42,
  124.             'y': 23 })
  125.         for i in u2.keys():
  126.             self.assertEqual(u2.get(i), u2[i])
  127.             self.assertEqual(u1.get(i), d1.get(i))
  128.             self.assertEqual(u0.get(i), d0.get(i))
  129.         
  130.         for i in xrange(20):
  131.             u2[i] = str(i)
  132.         
  133.         ikeys = []
  134.         for k in u2:
  135.             ikeys.append(k)
  136.         
  137.         keys = u2.keys()
  138.         self.assertEqual(set(ikeys), set(keys))
  139.         t = UserDict.UserDict()
  140.         self.assertEqual(t.setdefault('x', 42), 42)
  141.         self.assert_(t.has_key('x'))
  142.         self.assertEqual(t.setdefault('x', 23), 42)
  143.         t = UserDict.UserDict(x = 42)
  144.         self.assertEqual(t.pop('x'), 42)
  145.         self.assertRaises(KeyError, t.pop, 'x')
  146.         self.assertEqual(t.pop('x', 1), 1)
  147.         t['x'] = 42
  148.         self.assertEqual(t.pop('x', 1), 42)
  149.         t = UserDict.UserDict(x = 42)
  150.         self.assertEqual(t.popitem(), ('x', 42))
  151.         self.assertRaises(KeyError, t.popitem)
  152.  
  153.  
  154.  
  155. class SeqDict(UserDict.DictMixin):
  156.     '''Dictionary lookalike implemented with lists.
  157.  
  158.     Used to test and demonstrate DictMixin
  159.     '''
  160.     
  161.     def __init__(self, other = None, **kwargs):
  162.         self.keylist = []
  163.         self.valuelist = []
  164.         if other is not None:
  165.             for key, value in other:
  166.                 self[key] = value
  167.             
  168.         
  169.         for key, value in kwargs.iteritems():
  170.             self[key] = value
  171.         
  172.  
  173.     
  174.     def __getitem__(self, key):
  175.         
  176.         try:
  177.             i = self.keylist.index(key)
  178.         except ValueError:
  179.             raise KeyError
  180.  
  181.         return self.valuelist[i]
  182.  
  183.     
  184.     def __setitem__(self, key, value):
  185.         
  186.         try:
  187.             i = self.keylist.index(key)
  188.             self.valuelist[i] = value
  189.         except ValueError:
  190.             self.keylist.append(key)
  191.             self.valuelist.append(value)
  192.  
  193.  
  194.     
  195.     def __delitem__(self, key):
  196.         
  197.         try:
  198.             i = self.keylist.index(key)
  199.         except ValueError:
  200.             raise KeyError
  201.  
  202.         self.keylist.pop(i)
  203.         self.valuelist.pop(i)
  204.  
  205.     
  206.     def keys(self):
  207.         return list(self.keylist)
  208.  
  209.     
  210.     def copy(self):
  211.         d = self.__class__()
  212.         for key, value in self.iteritems():
  213.             d[key] = value
  214.         
  215.         return d
  216.  
  217.     
  218.     def fromkeys(cls, keys, value = None):
  219.         d = cls()
  220.         for key in keys:
  221.             d[key] = value
  222.         
  223.         return d
  224.  
  225.     fromkeys = classmethod(fromkeys)
  226.  
  227.  
  228. class UserDictMixinTest(mapping_tests.TestMappingProtocol):
  229.     type2test = SeqDict
  230.     
  231.     def test_all(self):
  232.         s = SeqDict()
  233.         s[10] = 'ten'
  234.         s[20] = 'twenty'
  235.         s[30] = 'thirty'
  236.         del s[20]
  237.         self.assertEqual(s[10], 'ten')
  238.         self.assertEqual(s.keys(), [
  239.             10,
  240.             30])
  241.         self.assert_(s.has_key(10))
  242.         self.assert_(not s.has_key(20))
  243.         self.assert_(10 in s)
  244.         self.assert_(20 not in s)
  245.         []([ k for k in s ], [
  246.             10,
  247.             30])
  248.         self.assertEqual(len(s), 2)
  249.         self.assertEqual(list(s.iteritems()), [
  250.             (10, 'ten'),
  251.             (30, 'thirty')])
  252.         self.assertEqual(list(s.iterkeys()), [
  253.             10,
  254.             30])
  255.         self.assertEqual(list(s.itervalues()), [
  256.             'ten',
  257.             'thirty'])
  258.         self.assertEqual(s.values(), [
  259.             'ten',
  260.             'thirty'])
  261.         self.assertEqual(s.items(), [
  262.             (10, 'ten'),
  263.             (30, 'thirty')])
  264.         self.assertEqual(s.get(10), 'ten')
  265.         self.assertEqual(s.get(15, 'fifteen'), 'fifteen')
  266.         self.assertEqual(s.get(15), None)
  267.         self.assertEqual(s.setdefault(40, 'forty'), 'forty')
  268.         self.assertEqual(s.setdefault(10, 'null'), 'ten')
  269.         del s[40]
  270.         self.assertEqual(s.pop(10), 'ten')
  271.         self.assert_(10 not in s)
  272.         s[10] = 'ten'
  273.         self.assertEqual(s.pop('x', 1), 1)
  274.         s['x'] = 42
  275.         self.assertEqual(s.pop('x', 1), 42)
  276.         (k, v) = s.popitem()
  277.         self.assert_(k not in s)
  278.         s[k] = v
  279.         s.clear()
  280.         self.assertEqual(len(s), 0)
  281.         self.assertRaises(KeyError, s.popitem)
  282.         s.update({
  283.             10: 'ten',
  284.             20: 'twenty' })
  285.         self.assertEqual(s[10], 'ten')
  286.         self.assertEqual(s[20], 'twenty')
  287.         self.assertEqual(s, {
  288.             10: 'ten',
  289.             20: 'twenty' })
  290.         t = SeqDict()
  291.         t[20] = 'twenty'
  292.         t[10] = 'ten'
  293.         self.assertEqual(s, t)
  294.  
  295.  
  296.  
  297. def test_main():
  298.     test_support.run_unittest(UserDictTest, UserDictMixinTest)
  299.  
  300. if __name__ == '__main__':
  301.     test_main()
  302.  
  303.